package com.practices.util;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.regex.Pattern;

public class StringUtils2 {

	/**
	 * 将某个日期以固定格式转化成字符串
	 * 
	 * @param date
	 * @return String
	 */
	public static String dateToStr(java.util.Date date) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String str = sdf.format(date);
		return str;
	}

	/**
	 * 判断任意一个整数是否素数
	 * 
	 * @param n
	 * @return boolean
	 */
	public static boolean isPrimes(int n) {
		for (int i = 2; i <= Math.sqrt(n); i++) {
			if (n % i == 0) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 获得任意一个整数的阶乘，递归
	 * 
	 * @param n
	 * @return n!
	 */
	public static int factorial(int n) {
		if (n == 1) {
			return 1;
		}
		return n * factorial(n - 1);
	}

	/**
	 * 分割字符串
	 * 
	 * @param str
	 *            String 原始字符串
	 * @param splitsign
	 *            String 分隔符
	 * @return String[] 分割后的字符串数组
	 */
	@SuppressWarnings("unchecked")
	public static String[] split(String str, String splitsign) {
		int index;
		if (str == null || splitsign == null)
			return null;
		ArrayList al = new ArrayList();
		while ((index = str.indexOf(splitsign)) != -1) {
			al.add(str.substring(0, index));
			str = str.substring(index + splitsign.length());
		}
		al.add(str);
		return (String[]) al.toArray(new String[0]);
	}

	/**
	 * 替换字符串
	 * 
	 * @param from
	 *            String 原始字符串
	 * @param to
	 *            String 目标字符串
	 * @param source
	 *            String 母字符串
	 * @return String 替换后的字符串
	 */
	public static String replace(String from, String to, String source) {
		if (source == null || from == null || to == null)
			return null;
		StringBuffer bf = new StringBuffer("");
		int index = -1;
		while ((index = source.indexOf(from)) != -1) {
			bf.append(source.substring(0, index) + to);
			source = source.substring(index + from.length());
			index = source.indexOf(from);
		}
		bf.append(source);
		return bf.toString();
	}

	/**
	 * 替换字符串，能能够在HTML页面上直接显示(替换双引号和小于号)
	 * 
	 * @param str
	 *            String 原始字符串
	 * @return String 替换后的字符串
	 */
	public static String htmlencode(String str) {
		if (str == null) {
			return null;
		}

		return replace("\"", "&quot;", replace("<", "&lt;", str));
	}

	/**
	 * 替换字符串，将被编码的转换成原始码（替换成双引号和小于号）
	 * 
	 * @param str
	 *            String
	 * @return String
	 */
	public static String htmldecode(String str) {
		if (str == null) {
			return null;
		}

		return replace("&quot;", "\"", replace("&lt;", "<", str));
	}

	private static final String _BR = "<br/>";

	/**
	 * 在页面上直接显示文本内容，替换小于号，空格，回车，TAB
	 * 
	 * @param str
	 *            String 原始字符串
	 * @return String 替换后的字符串
	 */
	public static String htmlshow(String str) {
		if (str == null) {
			return null;
		}

		str = replace("<", "&lt;", str);
		str = replace(" ", "&nbsp;", str);
		str = replace("\r\n", _BR, str);
		str = replace("\n", _BR, str);
		str = replace("\t", "&nbsp;&nbsp;&nbsp;&nbsp;", str);
		return str;
	}

	/**
	 * 返回指定字节长度的字符串
	 * 
	 * @param str
	 *            String 字符串
	 * @param length
	 *            int 指定长度
	 * @return String 返回的字符串
	 */
	public static String toLength(String str, int length) {
		if (str == null) {
			return null;
		}
		if (length <= 0) {
			return "";
		}
		try {
			if (str.getBytes("GBK").length <= length) {
				return str;
			}
		} catch (Exception ex) {
		}
		StringBuffer buff = new StringBuffer();

		int index = 0;
		char c;
		length -= 3;
		while (length > 0) {
			c = str.charAt(index);
			if (c < 128) {
				length--;
			} else {
				length--;
				length--;
			}
			buff.append(c);
			index++;
		}
		buff.append("...");
		return buff.toString();
	}

	/**
	 * 判断是否为整数
	 * 
	 * @param str
	 *            传入的字符串
	 * @return 是整数返回true,否则返回false
	 */
	public static boolean isInteger(String str) {
		Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
		return pattern.matcher(str).matches();
	}

	/**
	 * 判断是否为浮点数，包括double和float
	 * 
	 * @param str
	 *            传入的字符串
	 * @return 是浮点数返回true,否则返回false
	 */
	public static boolean isDouble(String str) {
		Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");
		return pattern.matcher(str).matches();
	}

	/**
	 * 判断输入的字符串是否符合Email样式.
	 * 
	 * @param str
	 *            传入的字符串
	 * @return 是Email样式返回true,否则返回false
	 */
	public static boolean isEmail(String str) {
		Pattern pattern = Pattern.compile("^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$");
		return pattern.matcher(str).matches();
	}

	/**
	 * 判断输入的字符串是否为纯汉字
	 * 
	 * @param str
	 *            传入的字符窜
	 * @return 如果是纯汉字返回true,否则返回false
	 */
	public static boolean isChinese(String str) {
		Pattern pattern = Pattern.compile("[\u0391-\uFFE5]+$");
		return pattern.matcher(str).matches();
	}

	/**
	 * 是否为空白,包括null和""
	 * 
	 * @param str
	 * @return
	 */
	public static boolean isBlank(String str) {
		return str == null || str.trim().length() == 0;
	}

	/**
	 * 判断是否为质数
	 * 
	 * @param x
	 * @return
	 */
	public static boolean isPrime(int x) {
		if (x <= 7) {
			if (x == 2 || x == 3 || x == 5 || x == 7)
				return true;
		}
		int c = 7;
		if (x % 2 == 0)
			return false;
		if (x % 3 == 0)
			return false;
		if (x % 5 == 0)
			return false;
		int end = (int) Math.sqrt(x);
		while (c <= end) {
			if (x % c == 0) {
				return false;
			}
			c += 4;
			if (x % c == 0) {
				return false;
			}
			c += 2;
			if (x % c == 0) {
				return false;
			}
			c += 4;
			if (x % c == 0) {
				return false;
			}
			c += 2;
			if (x % c == 0) {
				return false;
			}
			c += 4;
			if (x % c == 0) {
				return false;
			}
			c += 6;
			if (x % c == 0) {
				return false;
			}
			c += 2;
			if (x % c == 0) {
				return false;
			}
			c += 6;
		}
		return true;
	}

//	/**
//	 * 人民币转成大写
//	 * 
//	 * @param value
//	 * @return String
//	 */
//	public static String hangeToBig(double value) {
//		
//		char[] hunit = { '拾', '佰', '仟' }; // 段内位置表示
//		char[] vunit = { '万', '亿' }; // 段名表示
//		char[] digit = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' }; // 数字表示
//		long midVal = (long) (value * 100); // 转化成整形
//		String valStr = String.valueOf(midVal); // 转化成字符串
//
//		String head = valStr.substring(0, valStr.length() - 2); // 取整数部分
//		String rail = valStr.substring(valStr.length() - 2); // 取小数部分
//
//		String prefix = ""; // 整数部分转化的结果
//		String suffix = ""; // 小数部分转化的结果
//		// 处理小数点后面的数
//		if (rail.equals("00")) { // 如果小数部分为0
//			suffix = "整";
//		} else {
//			suffix = digit[rail.charAt(0) - '0'] + "角" + digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来
//		}
//		// 处理小数点前面的数
//		char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组
//		char zero = '0'; // 标志'0'表示出现过0
//		byte zeroSerNum = 0; // 连续出现0的次数
//		for (int i = 0; i < chDig.length; i++) { // 循环处理每个数字
//			int idx = (chDig.length - i - 1) % 4; // 取段内位置
//			int vidx = (chDig.length - i - 1) / 4; // 取段位置
//			if (chDig == '0') { // 如果当前字符是0
//				zeroSerNum++; // 连续0次数递增
//				if (zero == '0') { // 标志
//					zero = digit[0];
//				} else if (idx == 0 && vidx > 0 && zeroSerNum < 4) {
//					prefix += vunit[vidx - 1];
//					zero = '0';
//				}
//				continue;
//			}
//			zeroSerNum = 0; // 连续0次数清零
//			if (zero != '0') { // 如果标志不为0,则加上,例如万,亿什么的
//				prefix += zero;
//				zero = '0';
//			}
//			prefix += digit[chDig - '0']; // 转化该数字表示
//			if (idx > 0)
//				prefix += hunit[idx - 1];
//			if (idx == 0 && vidx > 0) {
//				prefix += vunit[vidx - 1]; // 段结束位置应该加上段名如万,亿
//			}
//		}
//
//		if (prefix.length() > 0)
//			prefix += '圆'; // 如果整数部分存在,则有圆的字样
//		return prefix + suffix; // 返回正确表示
//	}
//
//	/**
//	 * 全角字符转半角字符
//	 * 
//	 * @param QJStr
//	 * @return String
//	 */
//	public static final String QJToBJChange(String QJStr) {
//		char[] chr = QJStr.toCharArray();
//		String str = "";
//		for (int i = 0; i < chr.length; i++) {
//			chr = (char) ((int) chr - 65248);
//			str += chr;
//		}
//		return str;
//	}
//
//	/**
//	 * 去掉字符串中重复的子字符串
//	 * 
//	 * @param str
//	 * @return String
//	 */
//	private static String removeSameString(String str) {
//		Set<String> mLinkedSet = new LinkedHashSet<String>();
//		String[] strArray = str.split(" ");
//		StringBuffer sb = new StringBuffer();
//
//		for (int i = 0; i < strArray.length; i++) {
//			if (!mLinkedSet.contains(strArray)) {
//				mLinkedSet.add(strArray);
//				sb.append(strArray + " ");
//			}
//		}
//		System.out.println(mLinkedSet);
//		return sb.toString().substring(0, sb.toString().length() - 1);
//	}

	// 过滤特殊字符
	public static String encoding(String src) {
		if (src == null)
			return "";
		StringBuilder result = new StringBuilder();
		if (src != null) {
			src = src.trim();
			for (int pos = 0; pos < src.length(); pos++) {
				switch (src.charAt(pos)) {
				case '\"':
					result.append("&quot;");
					break;
				case '<':
					result.append("&lt;");
					break;
				case '>':
					result.append("&gt;");
					break;
				case '\'':
					result.append("&apos;");
					break;
				case '&':
					result.append("&amp;");
					break;
				case '%':
					result.append("&pc;");
					break;
				case '_':
					result.append("&ul;");
					break;
				case '#':
					result.append("&shap;");
					break;
				case '?':
					result.append("&ques;");
					break;
				default:
					result.append(src.charAt(pos));
					break;
				}
			}
		}
		return result.toString();
	}

	// 反过滤特殊字符
	public static String decoding(String src) {
		if (src == null)
			return "";
		String result = src;
		result = result.replace("&quot;", "\"").replace("&apos;", "\'");
		result = result.replace("&lt;", "<").replace("&gt;", ">");
		result = result.replace("&amp;", "&");
		result = result.replace("&pc;", "%").replace("&ul", "_");
		result = result.replace("&shap;", "#").replace("&ques", "?");
		return result;
	}

	
	
	/**
	  * 判断是不是合法字符
	  * c 要判断的字符
	  */
	public static boolean isLetter(String c) {
	  boolean result = false;

	  if (c==null || c.length()<0) {
	   return false;
	  }
	  //a-z
	  if (c.compareToIgnoreCase("a")>=0 && c.compareToIgnoreCase("z")<=0) {
	   return true;
	  }
	  //0-9
	  if (c.compareToIgnoreCase("0")>=0 && c.compareToIgnoreCase("9")<=0) {
	   return true;
	  }
	  //. - _
	  if (c.equals(".") || c.equals("-") || c.equals("_") ) {
	   return true;
	  }
	  return result;
	}
	 /**
	  * 从指定的字符串中提取Email
	  * content 指定的字符串
	  */
	public static String parse(String content) {
	  String email = null;
	  if (content==null || content.length()<1) {
	   return email;
	  }
	  //找出含有@
	  int beginPos;
	  int i;
	  String token = "@";
	  String preHalf="";
	  String sufHalf = "";

	  beginPos = content.indexOf(token);
	  if (beginPos>-1) {
	   //前项扫描
	   String s = null;
	   i= beginPos;
	   while(i>0) {
	    s = content.substring(i-1,i);
	    if (isLetter(s))
	     preHalf = s+preHalf;
	    else
	     break;
	    i--;
	   }
	   //后项扫描
	   i= beginPos+1;
	   while( i<content.length()) {
	    s = content.substring(i,i+1);
	    if (isLetter(s))
	     sufHalf =  sufHalf +s;
	    else
	     break;
	    i++;  
	   }
	   //判断合法性
	   email = preHalf + "@" + sufHalf;
	   if (isEmail(email)) {
	    return email;
	   }
	  }
	  return null;
	}
	
	
	 /**
     * Description: 转译特殊符号标签
     * @param value 需要处理的字符串
     * @return
     */
     public static String filter(String value)
        {
            if(value == null || value.length() == 0)
                return value;
            StringBuffer result = null;
            String filtered = null;
            for(int i = 0; i < value.length(); i++)
            {
                filtered = null;
                switch(value.charAt(i))
                {
                case 60: // '<'
                    filtered = "&lt;";
                    break;

                case 62: // '>'
                    filtered = "&gt;";
                    break;

                case 38: // '&'
                    filtered = "&amp;";
                    break;

                case 34: // '"'
                    filtered = "&quot;";
                    break;

                case 39: // '\''
                    filtered = "&#39;";
                    break;
                }
                if(result == null)
                {
                    if(filtered != null)
                    {
                        result = new StringBuffer(value.length() + 50);
                        if(i > 0)
                            result.append(value.substring(0, i));
                        result.append(filtered);
                    }
                } else
                if(filtered == null)
                    result.append(value.charAt(i));
                else
                    result.append(filtered);
            }

            return result != null ? result.toString() : value;
        }
	
	
}
